package com.kfm.coll;

import com.kfm.ex.Person;

import java.util.*;

public class HeroManage {

    // 创建一个容器存储所有的角色信息
    ArrayList arrayList = new ArrayList<>();

    public void addHero(Hero hero) {
        arrayList.add(hero);
    }

    // 如何扩容 如何重写 toString()
    // 如何排序
    public Hero getOne(String name) {
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Hero h = (Hero) iterator.next();
            if (name.equals(h.getName())) {
                return h;
            }
        }
        return null;
    }

    public void showAll() {
        System.out.println(arrayList);
    }

    public static void main(String[] args) {
        int[] arr = {2, 3, -1, -9, 0};
        // 冒泡
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] < arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 按照命座排序
     */
    public void sortByOrder() {
        // sort() 集合的元素拥有自然排序的能力就按照自然排序
        // 1. 要么是基本数据类型可以直接比较
        // 2. 要么就是实现了 Comparable 接口的类对象
        // 3. 如果说用的别人设计好的类，比较器（让对象被动的使用我的方式去比较）
        // Collections.sort(arrayList);
        Collections.sort(arrayList, new HeroComparator());
        // for (int i = 0; i < arrayList.size() - 1; i++) {
        //     for (int j = 0; j < arrayList.size() - 1 - i; j++) {
        //         Hero h1 = (Hero) arrayList.get(j);
        //         Hero h2 = (Hero) arrayList.get(j + 1);
        //         if (h1.getOrder() > h2.getOrder()) {
        //             // add(index, obj) --> 指定位置添加元素
        //             // set(index, obj) --> 替换掉指定位置的元素 将原来的元素返回
        //             arrayList.set(j, h2);
        //             arrayList.set(j + 1, h1);
        //         }
        //         // 对象不能直接比较 要使用某个属性进行比较
        //         // if (arrayList.get(j) < arrayList.get(j + 1)) {
        //         //
        //         // }
        //     }
        // }
        System.out.println(arrayList);
    }

    public void sortByLevel() {
        for (int i = 0; i < arrayList.size() - 1; i++) {
            for (int j = 0; j < arrayList.size() - 1 - i; j++) {
                Hero h1 = (Hero) arrayList.get(j);
                Hero h2 = (Hero) arrayList.get(j + 1);
                if (h1.compareTo(h2) > 0) {
                    // if (h1.getLevel() > h2.getLevel()) {
                    // add(index, obj) --> 指定位置添加元素
                    // set(index, obj) --> 替换掉指定位置的元素 将原来的元素返回
                    arrayList.set(j, h2);
                    arrayList.set(j + 1, h1);
                }
            }
        }
        System.out.println(arrayList);
    }

    public void sortByName() {
        for (int i = 0; i < arrayList.size() - 1; i++) {
            for (int j = 0; j < arrayList.size() - 1 - i; j++) {
                Hero h1 = (Hero) arrayList.get(j);
                Hero h2 = (Hero) arrayList.get(j + 1);
                // int byte 直接比较 自然比较的能力
                // 引用数据类型 需要实现 Comparable 接口，拥有自然比较的能力
                // compareTo()
                if (h1.getName().compareTo(h2.getName()) > 0) {
                    // add(index, obj) --> 指定位置添加元素
                    // set(index, obj) --> 替换掉指定位置的元素 将原来的元素返回
                    arrayList.set(j, h2);
                    arrayList.set(j + 1, h1);
                }
            }
        }
        System.out.println(arrayList);
    }
}

class HeroComparator implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        // 在这里定义两个对象如何进行比较
        Hero h1 = (Hero) o1;
        Hero h2 = (Hero) o2;
        return h1.getOrder() - h2.getOrder();
    }
}


